﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using DynamicAuditor.DTOs;

namespace DynamicAuditor.DALAuditor

{
    /// <summary>
    /// Fecha: 23-Octubre-2010
    /// Autor:Kenneth Bogantes F
    /// Descripcion: En esta clase se va a manejar todas las operaciones correspondientes a ACTIVIDADES A LOS PROCESOS COBIT tales como: Insercion, Actualizacion, Eliminacion
    /// </summary>



   public class clsProcesoActividadMg
    {
        #region conexion

        //Declaracion de la varaiable tipo datacontext que vamos a utilizar en toda la clase.
        DynamicAuditorDataContext bd = new DynamicAuditorDataContext();

        #endregion 

        #region Funciones_Basicas_Mantenimientos

        //--------------------------------------------------------------------------------------------------------------------------

        public int InsertProcesoActividad(DTOs.dtoProcesoActividad procesoActividad)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;
            PROCESOS_ACTIVIDADE nuevoRegistro = new PROCESOS_ACTIVIDADE();
            
            try
            {

                nuevoRegistro.idActvidad = procesoActividad.IdActividad;
                nuevoRegistro.idProceso = procesoActividad.ProcesoCobit.Idproceso;
                nuevoRegistro.idCliente = procesoActividad.Cliente.idCliente;
                nuevoRegistro.NombreActividad = procesoActividad.NombreActividad;
                nuevoRegistro.DescripcionActividad = procesoActividad.Descripcion;
                nuevoRegistro.Activo = procesoActividad.Activo;
                nuevoRegistro.isProcesoCobit = (bool)procesoActividad.IsProcesoCobit;
                //Se procede a insertar la informacion del Actividad del proceso cobit
                bd.PROCESOS_ACTIVIDADEs.InsertOnSubmit(nuevoRegistro);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo insertar el registro. " + ex.Message);

            }
            return x;
        }



        //--------------------------------------------------------------------------------------------------------------------------


        public int UpdateProcesoActividad(DTOs.dtoProcesoActividad procesoActividad)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;


            try
            {

                PROCESOS_ACTIVIDADE registro = bd.PROCESOS_ACTIVIDADEs.Single(p => p.idActvidad == procesoActividad.IdActividad);

                registro.idActvidad = procesoActividad.IdActividad;

                registro.idProceso = procesoActividad.ProcesoCobit.Idproceso;
                registro.idCliente = procesoActividad.Cliente.idCliente;
                registro.NombreActividad = procesoActividad.NombreActividad;
                registro.DescripcionActividad = procesoActividad.Descripcion;
                registro.Activo = procesoActividad.Activo;
                registro.isProcesoCobit = procesoActividad.IsProcesoCobit;

                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error actualizando el registro. " + ex.Message);
            }
            return x;
        }



        //--------------------------------------------------------------------------------------------------------------------------



        public int DeleteProcesoActividad(DTOs.dtoProcesoActividad procesoActividad)
        {
            //Se retorna un 1 si el proceso se realizo correctamente de lo contrario se retorna un 0

            int x = 0;

            try
            {

                var registro = bd.PROCESOS_ACTIVIDADEs.Single(p => p.idActvidad == procesoActividad.IdActividad);

                bd.PROCESOS_ACTIVIDADEs.DeleteOnSubmit(registro);
                bd.SubmitChanges();
                x = 1;
            }
            catch (Exception ex)
            {
                throw new Exception("No se pudo borrar el registro " + ex.Message);
                
            }

            return x;

        }


        //--------------------------------------------------------------------------------------------------------------------------



        public DTOs.dtoProcesoActividad ObtenerProcesoActividadporId(int idActividad)
        {
            DTOs.dtoProcesoActividad registro = new DynamicAuditor.DTOs.dtoProcesoActividad();

            try
            {
                PROCESOS_ACTIVIDADE dato = bd.PROCESOS_ACTIVIDADEs.Single(p => p.idActvidad == idActividad);

                registro.IdActividad = dato.idActvidad;
                registro.ProcesoCobit = new clsProcesoCobitMg().ObtenerProcesoCobitporId(int.Parse(dato.idProceso.ToString()));
                registro.Cliente = new clsClientesMg().ObtenerClienteporId(int.Parse(dato.idCliente.ToString()));
                registro.NombreActividad = dato.NombreActividad;
                registro.Descripcion = dato.DescripcionActividad;
                registro.IsProcesoCobit = bool.Parse(dato.isProcesoCobit.ToString());
                registro.Activo = bool.Parse(dato.Activo.ToString());


            }
            catch (Exception ex)
            {

                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
                return null;
            }

            return registro;
        }



       






        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoProcesoActividad> ObtenerProcesosActividadesLista(int idproceso)
        {
            int i = 0;
            List<DTOs.dtoProcesoActividad> listaDatos = new List<DTOs.dtoProcesoActividad>();

            try
            {
                var datos = (from p in bd.PROCESOS_ACTIVIDADEs
                             from d in bd.PROCESOS_COBITs
                             from c in bd.CLIENTEs
                             where p.idProceso == d.idProceso && p.idCliente == c.IdCliente && p.idProceso == idproceso
                             orderby p.idActvidad
                             select new { p, d , c }

                           );

                foreach (var fila in datos)
                {
                    listaDatos.Add(new dtoProcesoActividad());

                    listaDatos[i].IdActividad = fila.p.idActvidad;
                    listaDatos[i].ProcesoCobit = toDTOProcesoCobit(fila.d);
                    listaDatos[i].Cliente = toDTOCliente(fila.c);
                    listaDatos[i].NombreActividad = fila.p.NombreActividad;
                    listaDatos[i].Descripcion = fila.p.DescripcionActividad;
                    listaDatos[i].Activo =(bool ) fila.p.Activo;
                    listaDatos[i].IsProcesoCobit =(bool) fila.p.isProcesoCobit;
                    
                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }
            return listaDatos;
        }


        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoProcesoActividad> ObtenerProcesosActividadesActivosLista(int idproceso)
        {
            int i = 0;
            List<DTOs.dtoProcesoActividad> listaDatos = new List<DTOs.dtoProcesoActividad>();

            try
            {
                var datos = (from p in bd.PROCESOS_ACTIVIDADEs
                             from d in bd.PROCESOS_COBITs
                             from c in bd.CLIENTEs
                             where p.idProceso == d.idProceso && p.idCliente == c.IdCliente && p.idProceso == idproceso
                             && p.Activo == true
                             orderby p.idActvidad
                             select new { p, d, c }

                           );

                foreach (var fila in datos)
                {
                    listaDatos.Add(new dtoProcesoActividad());

                    listaDatos[i].IdActividad = fila.p.idActvidad;
                    listaDatos[i].ProcesoCobit = toDTOProcesoCobit(fila.d);
                    listaDatos[i].Cliente = toDTOCliente(fila.c);
                    listaDatos[i].NombreActividad = fila.p.NombreActividad;
                    listaDatos[i].Descripcion = fila.p.DescripcionActividad;
                    listaDatos[i].Activo = (bool)fila.p.Activo;
                    listaDatos[i].IsProcesoCobit = (bool)fila.p.isProcesoCobit;

                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }
            return listaDatos;
        }


        //--------------------------------------------------------------------------------------------------------------------------



        public List<DTOs.dtoProcesoActividad> ObtenerProcesosActividadesByCliente(int idCliente)
        {
            int i = 0;
            List<DTOs.dtoProcesoActividad> listaDatos = new List<DTOs.dtoProcesoActividad>();

            try
            {
                var datos = (from p in bd.PROCESOS_ACTIVIDADEs
                             from d in bd.PROCESOS_COBITs
                             from c in bd.CLIENTEs
                             where p.idProceso == d.idProceso && p.idCliente == c.IdCliente && p.idCliente==idCliente
                             orderby p.idActvidad
                             select new { p, d, c }

                           );

                foreach (var fila in datos)
                {
                    listaDatos.Add(new dtoProcesoActividad());

                    listaDatos[i].IdActividad = fila.p.idActvidad;
                    listaDatos[i].ProcesoCobit = toDTOProcesoCobit(fila.d);
                    listaDatos[i].Cliente = toDTOCliente(fila.c);
                    listaDatos[i].NombreActividad = fila.p.NombreActividad;
                    listaDatos[i].Descripcion = fila.p.DescripcionActividad;
                    listaDatos[i].Activo = (bool)fila.p.Activo;
                    listaDatos[i].IsProcesoCobit = (bool)fila.p.isProcesoCobit;

                    i++;
                }

            }
            catch (Exception ex)
            {
                throw new Exception("Ocurrio un error obteniendo los datos. " + ex.Message);
            }
            return listaDatos;
        }



        //--------------------------------------------------------------------------------------------------------------------------



        private dtoProcesoCobit toDTOProcesoCobit(PROCESOS_COBIT procesoCobit)
        {
            dtoProcesoCobit nuevo = new dtoProcesoCobit();
            nuevo.Idproceso = procesoCobit.idProceso;
            nuevo.Siglasproceso = procesoCobit.SiglaProceso;
            nuevo.Nombreproceso = procesoCobit.NombreProceso;

            //para prevenir problemas de rendimiento simplemente se crea un nuevo objeto tipo dominio
            nuevo.Dominio = new clsProcesoCobitMg().toDTODominioCobit(procesoCobit.DOMINIO);
            nuevo.Descripcion = procesoCobit.Descripcion;
            nuevo.Activo = (bool) procesoCobit.Activo;          
            return nuevo;
        }


        private dtoCliente toDTOCliente(CLIENTE cliente)
        {
            dtoCliente nuevo = new dtoCliente();
            nuevo.idCliente = cliente.IdCliente;
            nuevo.CodCliente = cliente.CodCliente;
            nuevo.Nombre = cliente.Nombre;
            nuevo.Descripcion = cliente.Descripcion;
            nuevo.Contacto = cliente.Contacto;
            nuevo.Telefono = cliente.Telefono;
            nuevo.Email = cliente.Email;
            nuevo.FechaCreacion = (DateTime) cliente.FechaCreacion;
            nuevo.Activo = (bool) cliente.Activo;
            nuevo.ModificadoPor = (int) cliente.ModificadoPor;
            nuevo.FechaModificacion =(DateTime) cliente.FechaModificacion;





            return nuevo;
        }


        #endregion






    }
}
